It's impossible for failedTypeLocations to be empty if allowedTypes is empty, right? If allowedTypes is empty, there must be at least two occurrences of type that don't overlap. That means one must fail.

You are absolutely right here. One must fail. I will refine that .

Regarding integer vs number, I wasn’t fully clear on how to treat them either. I saw the patternProperties test using type:"integer", so I included "integer" in the initial allowedTypes set, . I initially did not include integer in the set which caused this particulr test to fail so i included it,but I now understand the problem: "integer" isn’t a standalone JSON type, and it has a subtype relationship with "number" .I also saw your note about needing to eliminate duplicate type messages so I'll try to incorporate that .

Did you forget to remove this if, or did you come up with a reason why it needs to be there?

Let's declare this set of all possible types as a constant at the top. It doesn't need to be recreated every time the function runs.

Hey @jdesrosiers
I did not declare allowedTypes as a constant at the top because it is getting updated ,let me take an example.

• For Example

allOf: [
  { "type": ["string", "number"] },
  { "type": ["string"] },
  { "type": ["string", "boolean"] }
]

• Instance

instance = "helloo"

and we have declared and initialized allowedTypes with let allowedTypes = new Set(["null", "boolean", "number", "string", "array", "object", "integer"]); and in the mean while all the typeKeywords are also getting processed one by one , So suppose the 1st typeKeyword the got processed was temp_set = {string,number} (i'm putting them in a set so that i can take intersection). Now we take intersection of this temp_set with allowedTypes.

temp_Set={string,number}
allowedTypes = new Set(["null", "boolean", "number", "string", "array", "object", "integer"]);

//updated allowedTypes
allowedTypes = (temp_Set) intersection (allowedTypes)  //we get string and number so it becomes allowedTypes={string,number}

Now next typeKeyword gets processed i.e string so,

temp_Set={string}
allowedTypes={string,number}

allowedTypes = (temp_Set) intersection (allowedTypes) // becomes allowedTypes={string}

Now at last typeKeyword that gets processed will be string & boolean

temp_Set={string, boolean}
allowedTypes={string}

allowedTypes = (temp_Set) intersection (allowedTypes) // becomes allowedTypes={string}

and hence our instance which was a string passes. and allowedType cannot be taken as constant.

• Now had our allowedTypes set finally became empty like in this case:

allOf: [
  { "type": ["string"] },
  { "type": ["number"] },
]

That means we have a type Conflict.

• But if its final size is greater than 1 then no Type conflict and normal type error handling will do the work.

This was my thought process but it seems like I need to do some more work to get the logic right . Thanks a lot for pinpointing the areas i need to consider.

I understand. I was thinking something like this,

const allTypes = new Set(["null", "boolean", "number", "string", "array", "object", "integer"]);

const type = async (normalizedErrors, instance, localization) => {
  if (normalizedErrors["https://json-schema.org/keyword/type"]) {
    let allowedTypes = allTypes;

    for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/type"]) {
      allowedTypes = allowedTypes.intersection(keywordTypes);
    }

allowedTypes needs to be reassigned because it's accumulating the result of multiple intersections, but we don't need to recreate the initial value every time. The set intersection operation is immutable, so we can create that set once and reuse it for each initialization of allowedTypes.

You shouldn't need to write custom set intersection logic. Conceptually, if a schema allows numbers, it also allows integers. If you code for that relationship, the rest should all just work.

you are right that would be much easier than any custom intersection logic. I've implemented this.

This isn't a great place to put this code. It would be more cohesive to put it after the for loop that builds allowedTypes. That way all the code that builds allowedTypes is in one place. Then all the code that reads allowedTypes comes after.

sure,moved that block right after the for loop that builds allowedTypes ends.

There's no reason to create a new set every time you initialize allowedTypes. ALL_TYPES can be a set.

I've changed that, ALL_TYPES is now a set instead of an array

Did you forget to remove this if, or did you come up with a reason why it needs to be there?